home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / mpeg_play-2.1 / fs2fast.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  8KB  |  349 lines
  1. /*
  2.  * fs2fast.c --
  3.  *
  4.  *      Procedures dealing with a fast version of Floyd-Steinberg
  5.  *      dithering with 2 error values propagated.
  6.  */
  7.  
  8. /*
  9.  * Copyright (c) 1995 The Regents of the University of California.
  10.  * All rights reserved.
  11.  * 
  12.  * Permission to use, copy, modify, and distribute this software and its
  13.  * documentation for any purpose, without fee, and without written agreement is
  14.  * hereby granted, provided that the above copyright notice and the following
  15.  * two paragraphs appear in all copies of this software.
  16.  * 
  17.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  18.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  19.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  20.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  21.  * 
  22.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  23.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  24.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  25.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  26.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  27.  */
  28.  
  29. #include "video.h"
  30. #include "proto.h"
  31. #include "dither.h"
  32. #include <malloc.h>
  33.  
  34. /* Arrays containing error values for floyd-steinberg dithering. */
  35.  
  36. static int deltay[256];
  37. static int deltau[256];
  38. static int deltav[256];
  39. static int deltay2[256];
  40. static int deltau2[256];
  41. static int deltav2[256];
  42.  
  43. /* Definitions governing number of bits used for luminance, cr, and cb. */
  44.  
  45. #define L_BITS 3
  46. #define CR_BITS 2
  47. #define CB_BITS 2
  48.  
  49. /* Masks for proper quantization of lum, cr, and cb values. */
  50.  
  51. #define L_MASK 0xe0
  52. #define CR_MASK 0xc0
  53. #define CB_MASK 0xc0
  54.  
  55.  
  56.  
  57. /*
  58.  *--------------------------------------------------------------
  59.  *
  60.  * InitFS2FastDither --
  61.  *
  62.  *    Initializes structures and arrays neeeded for fast implementation
  63.  *      of two error F-S dithering.
  64.  *
  65.  * Results:
  66.  *    None.
  67.  *
  68.  * Side effects:
  69.  *      None.
  70.  *
  71.  *--------------------------------------------------------------
  72.  */
  73.  
  74. void InitFS2FastDither()
  75. {
  76.   int i;
  77.   int lum_num, cr_num, cb_num;
  78.  
  79.   for (i=0; i<256; i++) {
  80.     lum_num = (i >> (8-L_BITS));
  81.     cr_num = (i >> (8-CR_BITS));
  82.     cb_num = (i >> (8-CB_BITS));
  83.  
  84.     /* These arrays contain the error values propogated for each pixel value 
  85.        for each channel. 
  86.     */
  87.  
  88.     deltay[i] = (i - ((int) lum_values[lum_num])) / 2;
  89.     deltau[i] = (i-((int) cr_values[cr_num])) / 2;
  90.     deltav[i] = (i-((int) cb_values[cb_num])) / 2;
  91.     deltay2[i] = (i - ((int) lum_values[lum_num])) - deltay[i];
  92.     deltau2[i] = (i - ((int) cr_values[cr_num])) - deltau[i];
  93.     deltav2[i] = (i - ((int) cb_values[cb_num])) - deltav[i];
  94.  
  95.   }
  96.  
  97. }
  98.  
  99.  
  100. /*
  101.  *--------------------------------------------------------------
  102.  *
  103.  * DitherImage --
  104.  *
  105.  *    Dithers an image using floyd-steinberg.
  106.  *    Assumptions made:
  107.  *      1) The color space is allocated y:cr:cb = 8:4:4
  108.  *      2) The spatial resolution of y:cr:cb is 4:1:1
  109.  *
  110.  * Results:
  111.  *    None.
  112.  *
  113.  * Side effects:
  114.  *    None.
  115.  *
  116.  *--------------------------------------------------------------
  117.  */
  118. void
  119. FS2FastDitherImage (lum, cr, cb, out, h, w)
  120.      unsigned char *lum;
  121.      unsigned char *cr;
  122.      unsigned char *cb;
  123.      unsigned char *out;
  124.      int w, h;
  125. {
  126.   int i, j, idx, idx2;
  127.   int y, u, v;
  128.   int dy, du, dv;
  129.   int code;
  130.   static int *yerr1;
  131.   static int *yerr2;
  132.   static int *uerr1;
  133.   static int *uerr2;
  134.   static int *verr1;
  135.   static int *verr2;
  136.   int *ye1, *ue1, *ve1;
  137.   int *ye2, *ue2, *ve2;
  138.   unsigned char *o, *l, *r, *b;
  139.   static int first = 1;
  140.  
  141.   /* If first time called, allocate error arrays. */
  142.  
  143.   if (first) {
  144.     first = 0;
  145.     yerr1 = (int *) malloc((w+5)*sizeof(int));
  146.     yerr2 = (int *) malloc((w+5)*sizeof(int));
  147.     uerr1 = (int *) malloc((w+5)*sizeof(int));
  148.     uerr2 = (int *) malloc((w+5)*sizeof(int));
  149.     verr1 = (int *) malloc((w+5)*sizeof(int));
  150.     verr2 = (int *) malloc((w+5)*sizeof(int));
  151.   }
  152.  
  153.   /*
  154.    * Init error arrays and variables.
  155.    */
  156.   memset ((char *)yerr1, 0, (w+5)*sizeof(int));
  157.   memset ((char *)yerr2, 0, (w+5)*sizeof(int));
  158.   memset ((char *)uerr1, 0, (w+5)*sizeof(int));
  159.   memset ((char *)uerr2, 0, (w+5)*sizeof(int));
  160.   memset ((char *)verr1, 0, (w+5)*sizeof(int));
  161.   memset ((char *)verr2, 0, (w+5)*sizeof(int));
  162.   du = dv = dy = 0;
  163.  
  164.   for (j=0; j<h; j+=2) {
  165.     ye1 = yerr1;
  166.     ue1 = uerr1;
  167.     ve1 = verr1;
  168.     ye2 = yerr2;
  169.     ue2 = uerr2;
  170.     ve2 = verr2;
  171.     idx = j*w;
  172.     idx2 = idx/4;
  173.     o = out+idx;
  174.     l = lum+idx;
  175.     r = cr+idx2;
  176.     b = cb+idx2;
  177.  
  178.     /* Do the top row in forward order. */
  179.     for (i=0; i<w; i+=2) {
  180.       /* Do left side of this pair... */
  181.       y = *l++ + dy + *ye1++;
  182.       u = *r + du + *ue1++;
  183.       v = *b + dv + *ve1++;
  184.  
  185.       if (y < 0) {
  186.         y = 0;
  187.       } else if (y > 255) {
  188.         y = 255;
  189.       }
  190.  
  191.       if (u < 0) {
  192.         u = 0;
  193.       } else if (u > 255) {
  194.         u = 255;
  195.       }
  196.  
  197.       if (v < 0) {
  198.         v = 0;
  199.       } else if (v > 255) {
  200.         v = 255;
  201.       }
  202.  
  203.       /*
  204.        * Construct a code using:
  205.        *    high order 3 bits of y, 
  206.        *    high order 2 bits of u, 
  207.        *    high order 2 bits of v
  208.        */
  209.       code = (((y & L_MASK) | ((u & CR_MASK) >> L_BITS) | (v >> (L_BITS+CR_BITS))) 
  210.           >> (8-(L_BITS+CR_BITS+CB_BITS)));
  211.       *o++ = pixel[code];
  212.       *ye2++ = deltay[y];
  213.       *ue2++ = deltau[u];
  214.       *ve2++ = deltav[v];
  215.       dy = deltay2[y];
  216.       du = deltau2[u];
  217.       dv = deltav2[v];
  218.  
  219.       /* Do right side of this pair... */
  220.       y = *l++ + dy + *ye1++;
  221.       u = *r++ + du + *ue1++;
  222.       v = *b++ + dv + *ve1++;
  223.  
  224.       if (y < 0) {
  225.         y = 0;
  226.       } else if (y > 255) {
  227.         y = 255;
  228.       }
  229.  
  230.       if (u < 0) {
  231.         u = 0;
  232.       } else if (u > 255) {
  233.         u = 255;
  234.       }
  235.  
  236.       if (v < 0) {
  237.         v = 0;
  238.       } else if (v > 255) {
  239.         v = 255;
  240.       }
  241.  
  242.       code = (((y & L_MASK) | ((u & CR_MASK) >> L_BITS) | (v >> (L_BITS+CR_BITS))) 
  243.           >> (8-(L_BITS+CR_BITS+CB_BITS)));
  244.       *o++ = pixel[code];
  245.       *ye2++ = deltay[y];
  246.       *ue2++ = deltau[u];
  247.       *ve2++ = deltav[v];
  248.       dy = deltay2[y];
  249.       du = deltau2[u];
  250.       dv = deltav2[v];
  251.  
  252.     }
  253.     
  254.     ye1 = yerr1+w-1;
  255.     ue1 = uerr1+w-1;
  256.     ve1 = verr1+w-1;
  257.     ye2 = yerr2+w-1;
  258.     ue2 = uerr2+w-1;
  259.     ve2 = verr2+w-1;
  260.     l += w-1;
  261.     o += w-1;
  262.     r--;
  263.     b--;
  264.     dy = du = dv = 0;
  265.  
  266.     /* Do bottom part of row, in right to left order. */
  267.     for (i=w-1; i>0; i-=2) {
  268.       /* Do right side of this pair... */
  269.       y = *l-- + dy + *ye2--;
  270.       u = *r + du + *ue2--;
  271.       v = *b + dv + *ve2--;
  272.  
  273.       if (y < 0) {
  274.         y = 0;
  275.       } else if (y > 255) {
  276.         y = 255;
  277.       }
  278.  
  279.       if (u < 0) {
  280.         u = 0;
  281.       } else if (u > 255) {
  282.         u = 255;
  283.       }
  284.  
  285.       if (v < 0) {
  286.         v = 0;
  287.       } else if (v > 255) {
  288.         v = 255;
  289.       }
  290.  
  291.       /*
  292.        * Construct a code using:
  293.        *    high order 3 bits of y, 
  294.        *    high order 2 bits of u, 
  295.        *    high order 2 bits of v
  296.        */
  297.       code = (((y & L_MASK) | ((u & CR_MASK) >> L_BITS) | (v >> (L_BITS+CR_BITS))) 
  298.           >> (8-(L_BITS+CR_BITS+CB_BITS)));
  299.       *o-- = pixel[code];
  300.       *ye1-- = deltay[y];
  301.       *ue1-- = deltau[u];
  302.       *ve1-- = deltav[v];
  303.       dy = deltay2[y];
  304.       du = deltau2[u];
  305.       dv = deltav2[v];
  306.  
  307.       /* Do left side of this pair... */
  308.       y = *l-- + dy + *ye2--;
  309.       u = *r-- + du + *ue2--;
  310.       v = *b-- + dv + *ve2--;
  311.  
  312.       if (y < 0) {
  313.         y = 0;
  314.       } else if (y > 255) {
  315.         y = 255;
  316.       }
  317.  
  318.       if (u < 0) {
  319.         u = 0;
  320.       } else if (u > 255) {
  321.         u = 255;
  322.       }
  323.  
  324.       if (v < 0) {
  325.         v = 0;
  326.       } else if (v > 255) {
  327.         v = 255;
  328.       }
  329.  
  330.  
  331.       code = (((y & L_MASK) | ((u & CR_MASK) >> L_BITS) | (v >> (L_BITS+CR_BITS))) 
  332.           >> (8-(L_BITS+CR_BITS+CB_BITS)));
  333.       *o-- = pixel[code];
  334.       *ye1-- = deltay[y];
  335.       *ue1-- = deltau[u];
  336.       *ve1-- = deltav[v];
  337.       dy = deltay2[y];
  338.       du = deltau2[u];
  339.       dv = deltav2[v];
  340.  
  341.     }
  342.   }
  343. }
  344.  
  345.  
  346.  
  347.  
  348.  
  349.